//创建者:Icarus
//手动滑稽,滑稽脸
//ヾ(•ω•`)o
//https://www.ykls.app
//2019年10月10日-00:25
//CabinIcarus.IcSkillSystem.Runtime

using System;
using UnityEngine;

namespace CabinIcarus.IcSkillSystem.SkillSystem.Runtime.Utils
{
    /// <summary>
    /// https://github.com/sebas77/Svelto.Common/blob/master/DataStructures/HashHelpers.cs
    /// </summary>
    public static class HashHelpers
       {
           public const int HashCollisionThreshold = 100;
   
           const Int32 HashPrime = 101;
   
           // Table of prime numbers to use as hash table sizes. 
           // A typical resize algorithm would pick the smallest prime number in this array
           // that is larger than twice the previous capacity. 
           // Suppose our Hashtable currently has capacity x and enough elements are added 
           // such that a resize needs to occur. Resizing first computes 2x then finds the 
           // first prime in the table greater than 2x, i.e. if primes are ordered 
           // p_1, p_2, ..., p_i, ..., it finds p_n such that p_n-1 < 2x < p_n. 
           // Doubling is important for preserving the asymptotic complexity of the 
           // hashtable operations such as add.  Having a prime guarantees that double 
           // hashing does not lead to infinite loops.  IE, your hash function will be 
           // h1(key) + i*h2(key), 0 <= i < size.  h2 and the size must be relatively prime.
           public static readonly int[] primes = {
               3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521, 631, 761, 919,
               1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591,
               17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363, 156437,
               187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403, 968897, 1162687, 1395263,
               1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 4999559, 5999471, 7199369};
   
           public static bool IsPrime(int candidate)
           {
               if ((candidate & 1) != 0)
               {
                   int limit = (int)Math.Sqrt(candidate);
                   for (int divisor = 3; divisor <= limit; divisor += 2)
                   {
                       if ((candidate % divisor) == 0)
                           return false;
                   }
                   return true;
               }
               return (candidate == 2);
           }
   
           public static int GetPrime(int min)
           {
               if (min < 0)
                   throw new ArgumentException();
   
               for (int i = 0; i < primes.Length; i++)
               {
                   int prime = primes[i];
                   if (prime >= min) return prime;
               }
   
               //outside of our predefined table. 
               //compute the hard way. 
               for (int i = (min | 1); i < Int32.MaxValue; i += 2)
               {
                   if (IsPrime(i) && ((i - 1) % HashPrime != 0))
                       return i;
               }
               return min;
           }
   
           // Returns size of hashtable to grow to.
           public static int ExpandPrime(int oldSize)
           {
               int newSize = 2 * oldSize;
   
               // Allow the hashtables to grow to maximum possible size (~2G elements) before encoutering capacity overflow.
               // Note that this check works even when _items.Length overflowed thanks to the (uint) cast
               if ((uint)newSize > MaxPrimeArrayLength && MaxPrimeArrayLength > oldSize)
               {
                   Debug.Assert(MaxPrimeArrayLength == GetPrime(MaxPrimeArrayLength), "Invalid MaxPrimeArrayLength");
                   return MaxPrimeArrayLength;
               }
   
               return GetPrime(newSize);
           }
   
   
           // This is the maximum prime smaller than Array.MaxArrayLength
           public const int MaxPrimeArrayLength = 0x7FEFFFFD;
       }
}